home *** CD-ROM | disk | FTP | other *** search
/ Champak 122 / Vol 122.iso / games / gem_stri.swf / scripts / DefineSprite_286 / frame_3 / DoAction.as
Encoding:
Text File  |  2011-01-06  |  75.5 KB  |  1,507 lines

  1. var ┬º\x01┬º = 426;
  2. loop0:
  3. while(true)
  4. {
  5.    if(eval("\x01") == 426)
  6.    {
  7.       set("\x01",eval("\x01") + 327);
  8.       ┬º┬ºpush(true);
  9.       continue;
  10.    }
  11.    if(eval("\x01") == 92)
  12.    {
  13.       set("\x01",eval("\x01") + 655);
  14.       ┬º┬ºpush(true);
  15.       continue;
  16.    }
  17.    if(eval("\x01") != 559)
  18.    {
  19.       if(eval("\x01") == 646)
  20.       {
  21.          set("\x01",eval("\x01") + 217);
  22.          break;
  23.       }
  24.       if(eval("\x01") == 753)
  25.       {
  26.          set("\x01",eval("\x01") - 194);
  27.          if(┬º┬ºpop())
  28.          {
  29.             set("\x01",eval("\x01") - 467);
  30.          }
  31.       }
  32.       else
  33.       {
  34.          if(eval("\x01") != 747)
  35.          {
  36.             if(eval("\x01") == 863)
  37.             {
  38.                set("\x01",eval("\x01") - 94);
  39.                stop();
  40.             }
  41.             break;
  42.          }
  43.          set("\x01",eval("\x01") - 101);
  44.          if(┬º┬ºpop())
  45.          {
  46.             set("\x01",eval("\x01") + 217);
  47.          }
  48.       }
  49.       continue;
  50.    }
  51.    set("\x01",eval("\x01") - 467);
  52.    while(true)
  53.    {
  54.       if(eval(┬º┬ºpop()) == 911)
  55.       {
  56.          set("\x01",eval("\x01") - 222);
  57.          if(┬º┬ºpop())
  58.          {
  59.             set("\x01",eval("\x01") + 136);
  60.          }
  61.       }
  62.       else if(eval("\x01") == 910)
  63.       {
  64.          set("\x01",eval("\x01") + 1);
  65.          ┬º┬ºpush(true);
  66.       }
  67.       else if(eval("\x01") == 919)
  68.       {
  69.          set("\x01",eval("\x01") - 228);
  70.          ┬º┬ºpush(true);
  71.       }
  72.       else if(eval("\x01") == 900)
  73.       {
  74.          set("\x01",eval("\x01") - 449);
  75.          if(┬º┬ºpop())
  76.          {
  77.             set("\x01",eval("\x01") - 322);
  78.          }
  79.       }
  80.       else if(eval("\x01") == 609)
  81.       {
  82.          set("\x01",eval("\x01") + 211);
  83.          if(┬º┬ºpop())
  84.          {
  85.             set("\x01",eval("\x01") - 464);
  86.          }
  87.       }
  88.       else if(eval("\x01") == 548)
  89.       {
  90.          set("\x01",eval("\x01") + 292);
  91.          if(┬º┬ºpop())
  92.          {
  93.             set("\x01",eval("\x01") + 79);
  94.          }
  95.       }
  96.       else
  97.       {
  98.          if(eval("\x01") == 438)
  99.          {
  100.             set("\x01",eval("\x01") + 214);
  101.             break loop0;
  102.          }
  103.          if(eval("\x01") == 840)
  104.          {
  105.             set("\x01",eval("\x01") + 79);
  106.             while(true)
  107.             {
  108.                if(┬º┬ºpop())
  109.                {
  110.                   set("\x01",eval("\x01") + 152);
  111.                   break loop0;
  112.                }
  113.                if(eval("\x01") == 663)
  114.                {
  115.                   set("\x01",eval("\x01") - 126);
  116.                   ┬º┬ºpush(true);
  117.                }
  118.                else
  119.                {
  120.                   if(eval("\x01") == 288)
  121.                   {
  122.                      set("\x01",eval("\x01") + 259);
  123.                      mx.skins.ColoredSkinElement.setColorStyle(this,"themeColor");
  124.                      break loop0;
  125.                   }
  126.                   if(eval("\x01") == 175)
  127.                   {
  128.                      set("\x01",eval("\x01") + 488);
  129.                      break loop0;
  130.                   }
  131.                   if(eval("\x01") == 197)
  132.                   {
  133.                      set("\x01",eval("\x01") + 353);
  134.                      ┬º┬ºpush(true);
  135.                   }
  136.                   else
  137.                   {
  138.                      if(eval("\x01") != 479)
  139.                      {
  140.                         break loop0;
  141.                      }
  142.                      set("\x01",eval("\x01") - 86);
  143.                      ┬º┬ºpush(true);
  144.                   }
  145.                }
  146.                while(true)
  147.                {
  148.                   if(eval("\x01") == 220)
  149.                   {
  150.                      set("\x01",eval("\x01") + 426);
  151.                      ┬º┬ºpush(true);
  152.                      continue;
  153.                   }
  154.                   if(eval("\x01") == 651)
  155.                   {
  156.                      set("\x01",eval("\x01") - 432);
  157.                      if(┬º┬ºpop())
  158.                      {
  159.                         set("\x01",eval("\x01") + 153);
  160.                      }
  161.                      continue;
  162.                   }
  163.                   if(eval("\x01") == 219)
  164.                   {
  165.                      set("\x01",eval("\x01") + 153);
  166.                      break loop0;
  167.                   }
  168.                   if(eval("\x01") == 800)
  169.                   {
  170.                      set("\x01",eval("\x01") - 606);
  171.                      if(┬º┬ºpop())
  172.                      {
  173.                         set("\x01",eval("\x01") + 3);
  174.                      }
  175.                      continue;
  176.                   }
  177.                   if(eval("\x01") == 406)
  178.                   {
  179.                      set("\x01",eval("\x01") - 203);
  180.                      if(┬º┬ºpop())
  181.                      {
  182.                         set("\x01",eval("\x01") + 645);
  183.                      }
  184.                      continue;
  185.                   }
  186.                   if(eval("\x01") == 646)
  187.                   {
  188.                      set("\x01",eval("\x01") + 290);
  189.                      if(┬º┬ºpop())
  190.                      {
  191.                         set("\x01",eval("\x01") - 457);
  192.                      }
  193.                      continue;
  194.                   }
  195.                   if(eval("\x01") == 848)
  196.                   {
  197.                      set("\x01",eval("\x01") - 197);
  198.                      ┬º┬ºpush(true);
  199.                      continue;
  200.                   }
  201.                   if(eval("\x01") == 843)
  202.                   {
  203.                      set("\x01",eval("\x01") - 43);
  204.                      ┬º┬ºpush(true);
  205.                      continue;
  206.                   }
  207.                   if(eval("\x01") == 936)
  208.                   {
  209.                      set("\x01",eval("\x01") - 457);
  210.                      break loop0;
  211.                   }
  212.                   if(eval("\x01") == 585)
  213.                   {
  214.                      set("\x01",eval("\x01") - 179);
  215.                      ┬º┬ºpush(true);
  216.                      continue;
  217.                   }
  218.                   if(eval("\x01") == 612)
  219.                   {
  220.                      set("\x01",eval("\x01") - 476);
  221.                      if(┬º┬ºpop())
  222.                      {
  223.                         set("\x01",eval("\x01") + 152);
  224.                      }
  225.                      continue;
  226.                   }
  227.                   if(eval("\x01") != 194)
  228.                   {
  229.                      if(eval("\x01") == 886)
  230.                      {
  231.                         set("\x01",eval("\x01") - 43);
  232.                         loop5:
  233.                         while(true)
  234.                         {
  235.                            set(┬º┬ºpop(),┬º┬ºpop() + 134);
  236.                            if(┬º┬ºpop())
  237.                            {
  238.                               set("\x01",eval("\x01") - 58);
  239.                            }
  240.                            while(true)
  241.                            {
  242.                               if(eval("\x01") == 81)
  243.                               {
  244.                                  set("\x01",eval("\x01") + 760);
  245.                                  ┬º┬ºpush(true);
  246.                               }
  247.                               else if(eval("\x01") == 248)
  248.                               {
  249.                                  set("\x01",eval("\x01") + 49);
  250.                                  ┬º┬ºpush(true);
  251.                               }
  252.                               else
  253.                               {
  254.                                  if(eval("\x01") == 228)
  255.                                  {
  256.                                     set("\x01",eval("\x01") + 276);
  257.                                     break loop0;
  258.                                  }
  259.                                  if(eval("\x01") == 329)
  260.                                  {
  261.                                     set("\x01",eval("\x01") + 528);
  262.                                     break loop0;
  263.                                  }
  264.                                  if(eval("\x01") == 618)
  265.                                  {
  266.                                     set("\x01",eval("\x01") - 80);
  267.                                     ┬º┬ºpush(true);
  268.                                  }
  269.                                  else if(eval("\x01") == 917)
  270.                                  {
  271.                                     set("\x01",eval("\x01") - 750);
  272.                                     ┬º┬ºpush(true);
  273.                                  }
  274.                                  else if(eval("\x01") == 483)
  275.                                  {
  276.                                     set("\x01",eval("\x01") - 100);
  277.                                     if(┬º┬ºpop())
  278.                                     {
  279.                                        set("\x01",eval("\x01") - 135);
  280.                                     }
  281.                                  }
  282.                                  else
  283.                                  {
  284.                                     if(eval("\x01") == 901)
  285.                                     {
  286.                                        set("\x01",eval("\x01") - 283);
  287.                                        break loop0;
  288.                                     }
  289.                                     if(eval("\x01") == 504)
  290.                                     {
  291.                                        set("\x01",eval("\x01") - 21);
  292.                                        ┬º┬ºpush(true);
  293.                                     }
  294.                                     else if(eval("\x01") == 57)
  295.                                     {
  296.                                        set("\x01",eval("\x01") + 272);
  297.                                        if(┬º┬ºpop())
  298.                                        {
  299.                                           set("\x01",eval("\x01") + 528);
  300.                                        }
  301.                                     }
  302.                                     else if(eval("\x01") == 297)
  303.                                     {
  304.                                        set("\x01",eval("\x01") + 604);
  305.                                        if(┬º┬ºpop())
  306.                                        {
  307.                                           set("\x01",eval("\x01") - 283);
  308.                                        }
  309.                                     }
  310.                                     else
  311.                                     {
  312.                                        if(eval("\x01") == 383)
  313.                                        {
  314.                                           set("\x01",eval("\x01") - 135);
  315.                                           break loop0;
  316.                                        }
  317.                                        if(eval("\x01") == 167)
  318.                                        {
  319.                                           set("\x01",eval("\x01") + 61);
  320.                                           if(┬º┬ºpop())
  321.                                           {
  322.                                              set("\x01",eval("\x01") + 276);
  323.                                           }
  324.                                        }
  325.                                        else
  326.                                        {
  327.                                           if(eval("\x01") == 149)
  328.                                           {
  329.                                              set("\x01",eval("\x01") + 827);
  330.                                              break loop0;
  331.                                           }
  332.                                           if(eval("\x01") == 975)
  333.                                           {
  334.                                              break loop5;
  335.                                           }
  336.                                           if(eval("\x01") == 538)
  337.                                           {
  338.                                              set("\x01",eval("\x01") - 268);
  339.                                              if(┬º┬ºpop())
  340.                                              {
  341.                                                 set("\x01",eval("\x01") - 164);
  342.                                              }
  343.                                           }
  344.                                           else
  345.                                           {
  346.                                              if(eval("\x01") == 841)
  347.                                              {
  348.                                                 break;
  349.                                              }
  350.                                              if(eval("\x01") == 270)
  351.                                              {
  352.                                                 set("\x01",eval("\x01") - 164);
  353.                                                 break loop0;
  354.                                              }
  355.                                              if(eval("\x01") == 106)
  356.                                              {
  357.                                                 set("\x01",eval("\x01") - 49);
  358.                                                 ┬º┬ºpush(true);
  359.                                              }
  360.                                              else if(eval("\x01") == 857)
  361.                                              {
  362.                                                 set("\x01",eval("\x01") - 403);
  363.                                                 ┬º┬ºpush(true);
  364.                                              }
  365.                                              else
  366.                                              {
  367.                                                 if(eval("\x01") != 454)
  368.                                                 {
  369.                                                    if(eval("\x01") == 976)
  370.                                                    {
  371.                                                       set("\x01",eval("\x01") - 856);
  372.                                                       mx.skins.ColoredSkinElement.setColorStyle(this,"themeColor");
  373.                                                    }
  374.                                                    break loop0;
  375.                                                 }
  376.                                                 set("\x01",eval("\x01") - 305);
  377.                                                 if(┬º┬ºpop())
  378.                                                 {
  379.                                                    set("\x01",eval("\x01") + 827);
  380.                                                 }
  381.                                              }
  382.                                           }
  383.                                        }
  384.                                     }
  385.                                  }
  386.                               }
  387.                            }
  388.                         }
  389.                         set("\x01",eval("\x01") - 58);
  390.                         break loop0;
  391.                      }
  392.                      if(eval("\x01") == 203)
  393.                      {
  394.                         set("\x01",eval("\x01") + 645);
  395.                         break loop0;
  396.                      }
  397.                      if(eval("\x01") == 376)
  398.                      {
  399.                         set("\x01",eval("\x01") + 209);
  400.                         break loop0;
  401.                      }
  402.                      if(eval("\x01") == 537)
  403.                      {
  404.                         set("\x01",eval("\x01") - 161);
  405.                         if(┬º┬ºpop())
  406.                         {
  407.                            set("\x01",eval("\x01") + 209);
  408.                         }
  409.                      }
  410.                      else if(eval("\x01") == 550)
  411.                      {
  412.                         set("\x01",eval("\x01") - 375);
  413.                         if(┬º┬ºpop())
  414.                         {
  415.                            set("\x01",eval("\x01") + 488);
  416.                         }
  417.                      }
  418.                      else if(eval("\x01") == 372)
  419.                      {
  420.                         set("\x01",eval("\x01") + 240);
  421.                         ┬º┬ºpush(true);
  422.                      }
  423.                      else
  424.                      {
  425.                         if(eval("\x01") != 393)
  426.                         {
  427.                            break;
  428.                         }
  429.                         set("\x01",eval("\x01") + 493);
  430.                         if(┬º┬ºpop())
  431.                         {
  432.                            set("\x01",eval("\x01") - 43);
  433.                         }
  434.                      }
  435.                      continue;
  436.                   }
  437.                   set("\x01",eval("\x01") + 3);
  438.                   loop7:
  439.                   while(true)
  440.                   {
  441.                      set(┬º┬ºpop(),┬º┬ºpop() - 528);
  442.                      loop8:
  443.                      while(true)
  444.                      {
  445.                         while(true)
  446.                         {
  447.                            if(eval("\x01") == 83)
  448.                            {
  449.                               set("\x01",eval("\x01") + 378);
  450.                               ┬º┬ºpush(true);
  451.                               continue;
  452.                            }
  453.                            if(eval("\x01") == 13)
  454.                            {
  455.                               set("\x01",eval("\x01") + 699);
  456.                               ┬º┬ºpush(┬º┬ºpop().substr(┬º┬ºpop(),┬º┬ºpop()));
  457.                               break loop0;
  458.                            }
  459.                            if(eval("\x01") == 468)
  460.                            {
  461.                               set("\x01",eval("\x01") - 455);
  462.                               if(┬º┬ºpop())
  463.                               {
  464.                                  set("\x01",eval("\x01") + 699);
  465.                               }
  466.                               continue;
  467.                            }
  468.                            if(eval("\x01") == 461)
  469.                            {
  470.                               set("\x01",eval("\x01") + 211);
  471.                               if(┬º┬ºpop())
  472.                               {
  473.                                  set("\x01",eval("\x01") - 145);
  474.                               }
  475.                               continue;
  476.                            }
  477.                            if(eval("\x01") == 430)
  478.                            {
  479.                               set("\x01",eval("\x01") + 211);
  480.                               break loop0;
  481.                            }
  482.                            if(eval("\x01") == 672)
  483.                            {
  484.                               set("\x01",eval("\x01") - 145);
  485.                               break loop0;
  486.                            }
  487.                            if(eval("\x01") == 938)
  488.                            {
  489.                               set("\x01",eval("\x01") - 681);
  490.                               ┬º┬ºpush(true);
  491.                               continue;
  492.                            }
  493.                            if(eval("\x01") == 360)
  494.                            {
  495.                               set("\x01",eval("\x01") - 245);
  496.                               ┬º┬ºpush(true);
  497.                               continue;
  498.                            }
  499.                            if(eval("\x01") == 771)
  500.                            {
  501.                               set("\x01",eval("\x01") - 303);
  502.                               ┬º┬ºpush(true);
  503.                               continue;
  504.                            }
  505.                            if(eval("\x01") != 888)
  506.                            {
  507.                               if(eval("\x01") == 115)
  508.                               {
  509.                                  set("\x01",eval("\x01") + 315);
  510.                                  if(┬º┬ºpop())
  511.                                  {
  512.                                     set("\x01",eval("\x01") + 211);
  513.                                  }
  514.                               }
  515.                               else
  516.                               {
  517.                                  if(eval("\x01") == 359)
  518.                                  {
  519.                                     break;
  520.                                  }
  521.                                  if(eval("\x01") == 510)
  522.                                  {
  523.                                     set("\x01",eval("\x01") - 151);
  524.                                     ┬º┬ºpush(true);
  525.                                  }
  526.                                  else
  527.                                  {
  528.                                     if(eval("\x01") == 919)
  529.                                     {
  530.                                        set("\x01",eval("\x01") - 409);
  531.                                        break loop0;
  532.                                     }
  533.                                     if(eval("\x01") == 361)
  534.                                     {
  535.                                        break loop8;
  536.                                     }
  537.                                     if(eval("\x01") == 277)
  538.                                     {
  539.                                        set("\x01",eval("\x01") + 661);
  540.                                        ┬º┬ºpush({});
  541.                                        break loop0;
  542.                                     }
  543.                                     if(eval("\x01") == 527)
  544.                                     {
  545.                                        set("\x01",eval("\x01") - 439);
  546.                                        ┬º┬ºpush(true);
  547.                                     }
  548.                                     else if(eval("\x01") == 88)
  549.                                     {
  550.                                        set("\x01",eval("\x01") + 831);
  551.                                        if(┬º┬ºpop())
  552.                                        {
  553.                                           set("\x01",eval("\x01") - 409);
  554.                                        }
  555.                                     }
  556.                                     else if(eval("\x01") == 641)
  557.                                     {
  558.                                        set("\x01",eval("\x01") + 240);
  559.                                        ┬º┬ºpush(true);
  560.                                     }
  561.                                     else if(eval("\x01") == 881)
  562.                                     {
  563.                                        set("\x01",eval("\x01") - 604);
  564.                                        if(┬º┬ºpop())
  565.                                        {
  566.                                           set("\x01",eval("\x01") + 661);
  567.                                        }
  568.                                     }
  569.                                     else
  570.                                     {
  571.                                        if(eval("\x01") != 257)
  572.                                        {
  573.                                           if(eval("\x01") == 712)
  574.                                           {
  575.                                              set("\x01",eval("\x01") - 103);
  576.                                              selected = false;
  577.                                              toggle = false;
  578.                                              enabled = true;
  579.                                              visible = true;
  580.                                              minHeight = 0;
  581.                                              ┬º┬ºpush("minWidth");
  582.                                              ┬º┬ºpush(0);
  583.                                           }
  584.                                           break loop0;
  585.                                        }
  586.                                        set("\x01",eval("\x01") + 104);
  587.                                        if(┬º┬ºpop())
  588.                                        {
  589.                                           set("\x01",eval("\x01") + 410);
  590.                                        }
  591.                                     }
  592.                                  }
  593.                               }
  594.                               continue;
  595.                            }
  596.                            set("\x01",eval("\x01") - 528);
  597.                            loop10:
  598.                            while(true)
  599.                            {
  600.                               set(┬º┬ºpop(),┬º┬ºpop() - ┬º┬ºpop());
  601.                               loop11:
  602.                               while(true)
  603.                               {
  604.                                  while(true)
  605.                                  {
  606.                                     if(eval("\x01") == 489)
  607.                                     {
  608.                                        set("\x01",eval("\x01") - 173);
  609.                                        ┬º┬ºpush(true);
  610.                                     }
  611.                                     else if(eval("\x01") == 620)
  612.                                     {
  613.                                        set("\x01",eval("\x01") + 93);
  614.                                        ┬º┬ºpush(true);
  615.                                     }
  616.                                     else if(eval("\x01") == 21)
  617.                                     {
  618.                                        set("\x01",eval("\x01") + 223);
  619.                                        if(┬º┬ºpop())
  620.                                        {
  621.                                           set("\x01",eval("\x01") + 477);
  622.                                        }
  623.                                     }
  624.                                     else if(eval("\x01") == 572)
  625.                                     {
  626.                                        set("\x01",eval("\x01") - 551);
  627.                                        ┬º┬ºpush(true);
  628.                                     }
  629.                                     else
  630.                                     {
  631.                                        if(eval("\x01") == 566)
  632.                                        {
  633.                                           set("\x01",eval("\x01") - 539);
  634.                                           break loop0;
  635.                                        }
  636.                                        if(eval("\x01") == 302)
  637.                                        {
  638.                                           set("\x01",eval("\x01") + 513);
  639.                                           ┬º┬ºpush(true);
  640.                                        }
  641.                                        else if(eval("\x01") == 225)
  642.                                        {
  643.                                           set("\x01",eval("\x01") + 770);
  644.                                           ┬º┬ºpush(true);
  645.                                        }
  646.                                        else
  647.                                        {
  648.                                           if(eval("\x01") == 602)
  649.                                           {
  650.                                              set("\x01",eval("\x01") - 10);
  651.                                              ┬º┬ºpop() extends new ┬º┬ºpop()[┬º┬ºpop() >> ┬º┬ºpop()]();
  652.                                              ┬º┬ºpush(┬º┬ºpop() >>> (┬º┬ºpop() >>> targetPath(┬º┬ºpop())));
  653.                                              break loop0;
  654.                                           }
  655.                                           if(eval("\x01") == 467)
  656.                                           {
  657.                                              set("\x01",eval("\x01") + 62);
  658.                                              ┬º┬ºpush(true);
  659.                                           }
  660.                                           else if(eval("\x01") == 316)
  661.                                           {
  662.                                              set("\x01",eval("\x01") + 250);
  663.                                              if(┬º┬ºpop())
  664.                                              {
  665.                                                 set("\x01",eval("\x01") - 539);
  666.                                              }
  667.                                           }
  668.                                           else if(eval("\x01") == 713)
  669.                                           {
  670.                                              set("\x01",eval("\x01") + 90);
  671.                                              if(┬º┬ºpop())
  672.                                              {
  673.                                                 set("\x01",eval("\x01") - 501);
  674.                                              }
  675.                                           }
  676.                                           else if(eval("\x01") == 815)
  677.                                           {
  678.                                              set("\x01",eval("\x01") - 213);
  679.                                              if(┬º┬ºpop())
  680.                                              {
  681.                                                 set("\x01",eval("\x01") - 10);
  682.                                              }
  683.                                           }
  684.                                           else
  685.                                           {
  686.                                              if(eval("\x01") == 831)
  687.                                              {
  688.                                                 set("\x01",eval("\x01") - 259);
  689.                                                 break loop0;
  690.                                              }
  691.                                              if(eval("\x01") == 995)
  692.                                              {
  693.                                                 set("\x01",eval("\x01") - 613);
  694.                                                 if(┬º┬ºpop())
  695.                                                 {
  696.                                                    set("\x01",eval("\x01") + 238);
  697.                                                 }
  698.                                              }
  699.                                              else
  700.                                              {
  701.                                                 if(eval("\x01") == 244)
  702.                                                 {
  703.                                                    break loop11;
  704.                                                 }
  705.                                                 if(eval("\x01") == 817)
  706.                                                 {
  707.                                                    set("\x01",eval("\x01") - 66);
  708.                                                    break loop0;
  709.                                                 }
  710.                                                 if(eval("\x01") == 803)
  711.                                                 {
  712.                                                    set("\x01",eval("\x01") - 501);
  713.                                                    break loop0;
  714.                                                 }
  715.                                                 if(eval("\x01") == 529)
  716.                                                 {
  717.                                                    set("\x01",eval("\x01") + 302);
  718.                                                    if(┬º┬ºpop())
  719.                                                    {
  720.                                                       set("\x01",eval("\x01") - 259);
  721.                                                    }
  722.                                                 }
  723.                                                 else
  724.                                                 {
  725.                                                    if(eval("\x01") == 622)
  726.                                                    {
  727.                                                       set("\x01",eval("\x01") - 155);
  728.                                                       break loop0;
  729.                                                    }
  730.                                                    if(eval("\x01") == 754)
  731.                                                    {
  732.                                                       set("\x01",eval("\x01") - 132);
  733.                                                       if(┬º┬ºpop())
  734.                                                       {
  735.                                                          set("\x01",eval("\x01") - 155);
  736.                                                       }
  737.                                                    }
  738.                                                    else if(eval("\x01") == 592)
  739.                                                    {
  740.                                                       set("\x01",eval("\x01") + 162);
  741.                                                       ┬º┬ºpush(true);
  742.                                                    }
  743.                                                    else if(eval("\x01") == 515)
  744.                                                    {
  745.                                                       set("\x01",eval("\x01") + 302);
  746.                                                       if(┬º┬ºpop())
  747.                                                       {
  748.                                                          set("\x01",eval("\x01") - 66);
  749.                                                       }
  750.                                                    }
  751.                                                    else
  752.                                                    {
  753.                                                       if(eval("\x01") == 825)
  754.                                                       {
  755.                                                          set("\x01",eval("\x01") - 600);
  756.                                                          break loop0;
  757.                                                       }
  758.                                                       if(eval("\x01") == 721)
  759.                                                       {
  760.                                                          set("\x01",eval("\x01") - 206);
  761.                                                          ┬º┬ºpush(true);
  762.                                                       }
  763.                                                       else
  764.                                                       {
  765.                                                          if(eval("\x01") == 382)
  766.                                                          {
  767.                                                             set("\x01",eval("\x01") + 238);
  768.                                                             loop13:
  769.                                                             while(true)
  770.                                                             {
  771.                                                                set(┬º┬ºpop(),┬º┬ºpop());
  772.                                                                if(┬º┬ºpop())
  773.                                                                {
  774.                                                                   set("\x01",eval("\x01") + 962);
  775.                                                                }
  776.                                                                while(true)
  777.                                                                {
  778.                                                                   if(eval("\x01") == 71)
  779.                                                                   {
  780.                                                                      set("\x01",eval("\x01") + 267);
  781.                                                                      ┬º┬ºpush(true);
  782.                                                                   }
  783.                                                                   else if(eval("\x01") == 526)
  784.                                                                   {
  785.                                                                      set("\x01",eval("\x01") - 447);
  786.                                                                      ┬º┬ºpush(true);
  787.                                                                   }
  788.                                                                   else
  789.                                                                   {
  790.                                                                      if(eval("\x01") == 607)
  791.                                                                      {
  792.                                                                         break;
  793.                                                                      }
  794.                                                                      if(eval("\x01") == 618)
  795.                                                                      {
  796.                                                                         set("\x01",eval("\x01") + 252);
  797.                                                                         if(┬º┬ºpop())
  798.                                                                         {
  799.                                                                            set("\x01",eval("\x01") - 344);
  800.                                                                         }
  801.                                                                      }
  802.                                                                      else
  803.                                                                      {
  804.                                                                         if(eval("\x01") == 869)
  805.                                                                         {
  806.                                                                            set("\x01",eval("\x01") - 308);
  807.                                                                            ┬º┬ºpush(┬º┬ºpop()[┬º┬ºpop()]() + 1);
  808.                                                                            break loop0;
  809.                                                                         }
  810.                                                                         if(eval("\x01") == 12)
  811.                                                                         {
  812.                                                                            break loop13;
  813.                                                                         }
  814.                                                                         if(eval("\x01") == 338)
  815.                                                                         {
  816.                                                                            set("\x01",eval("\x01") - 120);
  817.                                                                            if(┬º┬ºpop())
  818.                                                                            {
  819.                                                                               set("\x01",eval("\x01") + 733);
  820.                                                                            }
  821.                                                                         }
  822.                                                                         else
  823.                                                                         {
  824.                                                                            if(eval("\x01") == 218)
  825.                                                                            {
  826.                                                                               set("\x01",eval("\x01") + 733);
  827.                                                                               break loop0;
  828.                                                                            }
  829.                                                                            if(eval("\x01") == 25)
  830.                                                                            {
  831.                                                                               set("\x01",eval("\x01") + 128);
  832.                                                                               if(┬º┬ºpop())
  833.                                                                               {
  834.                                                                                  set("\x01",eval("\x01") + 728);
  835.                                                                               }
  836.                                                                            }
  837.                                                                            else if(eval("\x01") == 951)
  838.                                                                            {
  839.                                                                               set("\x01",eval("\x01") - 333);
  840.                                                                               ┬º┬ºpush(true);
  841.                                                                            }
  842.                                                                            else if(eval("\x01") == 79)
  843.                                                                            {
  844.                                                                               set("\x01",eval("\x01") + 790);
  845.                                                                               if(┬º┬ºpop())
  846.                                                                               {
  847.                                                                                  set("\x01",eval("\x01") - 308);
  848.                                                                               }
  849.                                                                            }
  850.                                                                            else
  851.                                                                            {
  852.                                                                               if(eval("\x01") == 153)
  853.                                                                               {
  854.                                                                                  set("\x01",eval("\x01") + 728);
  855.                                                                                  break loop0;
  856.                                                                               }
  857.                                                                               if(eval("\x01") == 870)
  858.                                                                               {
  859.                                                                                  set("\x01",eval("\x01") - 344);
  860.                                                                                  break loop0;
  861.                                                                               }
  862.                                                                               if(eval("\x01") == 561)
  863.                                                                               {
  864.                                                                                  set("\x01",eval("\x01") - 536);
  865.                                                                                  ┬º┬ºpush(true);
  866.                                                                               }
  867.                                                                               else if(eval("\x01") == 881)
  868.                                                                               {
  869.                                                                                  set("\x01",eval("\x01") - 274);
  870.                                                                                  ┬º┬ºpush(true);
  871.                                                                               }
  872.                                                                               else if(eval("\x01") == 974)
  873.                                                                               {
  874.                                                                                  set("\x01",eval("\x01") - 952);
  875.                                                                                  ┬º┬ºpush(true);
  876.                                                                               }
  877.                                                                               else if(eval("\x01") == 22)
  878.                                                                               {
  879.                                                                                  set("\x01",eval("\x01") + 354);
  880.                                                                                  if(┬º┬ºpop())
  881.                                                                                  {
  882.                                                                                     set("\x01",eval("\x01") + 326);
  883.                                                                                  }
  884.                                                                               }
  885.                                                                               else
  886.                                                                               {
  887.                                                                                  if(eval("\x01") == 376)
  888.                                                                                  {
  889.                                                                                     set("\x01",eval("\x01") + 326);
  890.                                                                                     break loop0;
  891.                                                                                  }
  892.                                                                                  if(eval("\x01") == 702)
  893.                                                                                  {
  894.                                                                                     set("\x01",eval("\x01") - 420);
  895.                                                                                     ┬º┬ºpush(true);
  896.                                                                                  }
  897.                                                                                  else
  898.                                                                                  {
  899.                                                                                     if(eval("\x01") != 282)
  900.                                                                                     {
  901.                                                                                        if(eval("\x01") == 996)
  902.                                                                                        {
  903.                                                                                           set("\x01",eval("\x01") - 782);
  904.                                                                                           break loop0;
  905.                                                                                        }
  906.                                                                                        if(eval("\x01") == 214)
  907.                                                                                        {
  908.                                                                                           set("\x01",eval("\x01") + 498);
  909.                                                                                           stop();
  910.                                                                                        }
  911.                                                                                        break loop0;
  912.                                                                                     }
  913.                                                                                     set("\x01",eval("\x01") + 714);
  914.                                                                                     if(┬º┬ºpop())
  915.                                                                                     {
  916.                                                                                        set("\x01",eval("\x01") - 782);
  917.                                                                                     }
  918.                                                                                  }
  919.                                                                               }
  920.                                                                            }
  921.                                                                         }
  922.                                                                      }
  923.                                                                   }
  924.                                                                }
  925.                                                             }
  926.                                                             set("\x01",eval("\x01") + 962);
  927.                                                             ┬º┬ºpush(!┬º┬ºpop());
  928.                                                             break loop0;
  929.                                                          }
  930.                                                          if(eval("\x01") == 781)
  931.                                                          {
  932.                                                             break;
  933.                                                          }
  934.                                                          if(eval("\x01") == 462)
  935.                                                          {
  936.                                                             set("\x01",eval("\x01") + 319);
  937.                                                             ┬º┬ºpush(true);
  938.                                                          }
  939.                                                          else
  940.                                                          {
  941.                                                             if(eval("\x01") == 751)
  942.                                                             {
  943.                                                                set("\x01",eval("\x01") - 275);
  944.                                                                stop();
  945.                                                                break loop0;
  946.                                                             }
  947.                                                             if(eval("\x01") == 795)
  948.                                                             {
  949.                                                                set("\x01",eval("\x01") - 333);
  950.                                                                set(┬º┬ºpop(),┬º┬ºpop() - 605);
  951.                                                                toggleHighQuality();
  952.                                                                break loop0;
  953.                                                             }
  954.                                                             if(eval("\x01") == 27)
  955.                                                             {
  956.                                                                set("\x01",eval("\x01") + 863);
  957.                                                                ┬º┬ºpush(true);
  958.                                                             }
  959.                                                             else
  960.                                                             {
  961.                                                                if(eval("\x01") != 890)
  962.                                                                {
  963.                                                                   break loop0;
  964.                                                                }
  965.                                                                set("\x01",eval("\x01") - 95);
  966.                                                                if(┬º┬ºpop())
  967.                                                                {
  968.                                                                   set("\x01",eval("\x01") - 333);
  969.                                                                }
  970.                                                             }
  971.                                                          }
  972.                                                       }
  973.                                                    }
  974.                                                 }
  975.                                              }
  976.                                           }
  977.                                        }
  978.                                     }
  979.                                  }
  980.                                  set("\x01",eval("\x01") + 44);
  981.                                  if(!┬º┬ºpop())
  982.                                  {
  983.                                     continue;
  984.                                  }
  985.                                  continue loop10;
  986.                               }
  987.                               set("\x01",eval("\x01") + 477);
  988.                               break loop0;
  989.                            }
  990.                         }
  991.                         set("\x01",eval("\x01") + 529);
  992.                         if(!┬º┬ºpop())
  993.                         {
  994.                            continue;
  995.                         }
  996.                         continue loop7;
  997.                      }
  998.                      set("\x01",eval("\x01") + 410);
  999.                      break loop0;
  1000.                   }
  1001.                }
  1002.             }
  1003.          }
  1004.          else
  1005.          {
  1006.             if(eval("\x01") == 800)
  1007.             {
  1008.                set("\x01",eval("\x01") + 24);
  1009.                eval(┬º┬ºconstant(2))[┬º┬ºconstant(8)][┬º┬ºconstant(9)](new ┬º\┬º\┬ºconstant(7)┬º(┬º┬ºconstant(6),┬º┬ºpop()));
  1010.                eval(┬º┬ºconstant(2))[┬º┬ºconstant(8)][┬º┬ºconstant(9)](new ┬º\┬º\┬ºconstant(7)┬º(┬º┬ºconstant(11),eval(┬º┬ºconstant(10))));
  1011.                eval(┬º┬ºconstant(12))[┬º┬ºconstant(13)] = eval(┬º┬ºconstant(2));
  1012.                break loop0;
  1013.             }
  1014.             if(eval("\x01") == 824)
  1015.             {
  1016.                set("\x01",eval("\x01") - 113);
  1017.                ┬º┬ºpush(true);
  1018.             }
  1019.             else if(eval("\x01") == 468)
  1020.             {
  1021.                set("\x01",eval("\x01") - 109);
  1022.                ┬º┬ºpush(true);
  1023.             }
  1024.             else if(eval("\x01") == 825)
  1025.             {
  1026.                set("\x01",eval("\x01") - 216);
  1027.                ┬º┬ºpush(true);
  1028.             }
  1029.             else if(eval("\x01") == 359)
  1030.             {
  1031.                set("\x01",eval("\x01") - 23);
  1032.                if(┬º┬ºpop())
  1033.                {
  1034.                   set("\x01",eval("\x01") + 18);
  1035.                }
  1036.             }
  1037.             else
  1038.             {
  1039.                if(eval("\x01") == 451)
  1040.                {
  1041.                   set("\x01",eval("\x01") - 322);
  1042.                   break loop0;
  1043.                }
  1044.                if(eval("\x01") == 691)
  1045.                {
  1046.                   set("\x01",eval("\x01") - 662);
  1047.                   if(┬º┬ºpop())
  1048.                   {
  1049.                      set("\x01",eval("\x01") + 439);
  1050.                   }
  1051.                }
  1052.                else if(eval("\x01") == 324)
  1053.                {
  1054.                   set("\x01",eval("\x01") + 114);
  1055.                   if(┬º┬ºpop())
  1056.                   {
  1057.                      set("\x01",eval("\x01") + 214);
  1058.                   }
  1059.                }
  1060.                else
  1061.                {
  1062.                   if(eval("\x01") == 29)
  1063.                   {
  1064.                      set("\x01",eval("\x01") + 439);
  1065.                      play();
  1066.                      break loop0;
  1067.                   }
  1068.                   if(eval("\x01") == 730)
  1069.                   {
  1070.                      set("\x01",eval("\x01") - 182);
  1071.                      ┬º┬ºpush(true);
  1072.                   }
  1073.                   else
  1074.                   {
  1075.                      if(eval("\x01") == 733)
  1076.                      {
  1077.                         set("\x01",eval("\x01") + 177);
  1078.                         loop19:
  1079.                         while(true)
  1080.                         {
  1081.                            set(┬º┬ºpop(),┬º┬ºpop() + 25);
  1082.                            if(┬º┬ºpop())
  1083.                            {
  1084.                               set("\x01",eval("\x01") + 467);
  1085.                            }
  1086.                            while(true)
  1087.                            {
  1088.                               if(eval("\x01") == 956)
  1089.                               {
  1090.                                  set("\x01",eval("\x01") - 757);
  1091.                                  ┬º┬ºpush(true);
  1092.                               }
  1093.                               else if(eval("\x01") == 187)
  1094.                               {
  1095.                                  set("\x01",eval("\x01") - 82);
  1096.                                  if(┬º┬ºpop())
  1097.                                  {
  1098.                                     set("\x01",eval("\x01") + 148);
  1099.                                  }
  1100.                               }
  1101.                               else if(eval("\x01") == 253)
  1102.                               {
  1103.                                  set("\x01",eval("\x01") + 423);
  1104.                                  ┬º┬ºpush(true);
  1105.                               }
  1106.                               else
  1107.                               {
  1108.                                  if(eval("\x01") == 199)
  1109.                                  {
  1110.                                     break;
  1111.                                  }
  1112.                                  if(eval("\x01") == 691)
  1113.                                  {
  1114.                                     set("\x01",eval("\x01") - 413);
  1115.                                     ┬º┬ºpush(true);
  1116.                                  }
  1117.                                  else
  1118.                                  {
  1119.                                     if(eval("\x01") == 548)
  1120.                                     {
  1121.                                        set("\x01",eval("\x01") - 360);
  1122.                                        break loop0;
  1123.                                     }
  1124.                                     if(eval("\x01") == 188)
  1125.                                     {
  1126.                                        set("\x01",eval("\x01") - 1);
  1127.                                        ┬º┬ºpush(true);
  1128.                                     }
  1129.                                     else
  1130.                                     {
  1131.                                        if(eval("\x01") == 834)
  1132.                                        {
  1133.                                           set("\x01",eval("\x01") - 65);
  1134.                                           break loop0;
  1135.                                        }
  1136.                                        if(eval("\x01") == 105)
  1137.                                        {
  1138.                                           break loop19;
  1139.                                        }
  1140.                                        if(eval("\x01") == 887)
  1141.                                        {
  1142.                                           set("\x01",eval("\x01") - 53);
  1143.                                           if(┬º┬ºpop())
  1144.                                           {
  1145.                                              set("\x01",eval("\x01") - 65);
  1146.                                           }
  1147.                                        }
  1148.                                        else if(eval("\x01") == 278)
  1149.                                        {
  1150.                                           set("\x01",eval("\x01") + 270);
  1151.                                           if(┬º┬ºpop())
  1152.                                           {
  1153.                                              set("\x01",eval("\x01") - 360);
  1154.                                           }
  1155.                                        }
  1156.                                        else if(eval("\x01") == 676)
  1157.                                        {
  1158.                                           set("\x01",eval("\x01") + 234);
  1159.                                           if(┬º┬ºpop())
  1160.                                           {
  1161.                                              set("\x01",eval("\x01") - 341);
  1162.                                           }
  1163.                                        }
  1164.                                        else if(eval("\x01") == 769)
  1165.                                        {
  1166.                                           set("\x01",eval("\x01") + 59);
  1167.                                           ┬º┬ºpush(true);
  1168.                                        }
  1169.                                        else if(eval("\x01") == 569)
  1170.                                        {
  1171.                                           set("\x01",eval("\x01") + 318);
  1172.                                           ┬º┬ºpush(true);
  1173.                                        }
  1174.                                        else
  1175.                                        {
  1176.                                           if(eval("\x01") == 910)
  1177.                                           {
  1178.                                              set("\x01",eval("\x01") - 341);
  1179.                                              break loop0;
  1180.                                           }
  1181.                                           if(eval("\x01") == 224)
  1182.                                           {
  1183.                                              set("\x01",eval("\x01") + 467);
  1184.                                              break loop0;
  1185.                                           }
  1186.                                           if(eval("\x01") != 828)
  1187.                                           {
  1188.                                              if(eval("\x01") == 98)
  1189.                                              {
  1190.                                                 set("\x01",eval("\x01") + 875);
  1191.                                                 nextFrame();
  1192.                                                 break loop0;
  1193.                                              }
  1194.                                              if(eval("\x01") == 973)
  1195.                                              {
  1196.                                                 set("\x01",eval("\x01") - 555);
  1197.                                                 stop();
  1198.                                              }
  1199.                                              break loop0;
  1200.                                           }
  1201.                                           set("\x01",eval("\x01") - 730);
  1202.                                           if(┬º┬ºpop())
  1203.                                           {
  1204.                                              set("\x01",eval("\x01") + 875);
  1205.                                           }
  1206.                                        }
  1207.                                     }
  1208.                                  }
  1209.                               }
  1210.                            }
  1211.                         }
  1212.                         set("\x01",eval("\x01") + 148);
  1213.                         break loop0;
  1214.                      }
  1215.                      if(eval("\x01") == 820)
  1216.                      {
  1217.                         set("\x01",eval("\x01") - 464);
  1218.                         break loop0;
  1219.                      }
  1220.                      if(eval("\x01") == 711)
  1221.                      {
  1222.                         set("\x01",eval("\x01") + 22);
  1223.                         if(┬º┬ºpop())
  1224.                         {
  1225.                            set("\x01",eval("\x01") + 177);
  1226.                         }
  1227.                      }
  1228.                      else if(eval("\x01") == 75)
  1229.                      {
  1230.                         set("\x01",eval("\x01") + 655);
  1231.                         while(true)
  1232.                         {
  1233.                            if(eval("\x01") == 451)
  1234.                            {
  1235.                               set("\x01",eval("\x01") + 167);
  1236.                               set(┬º┬ºpop(),┬º┬ºpop() - ┬º┬ºpop());
  1237.                               break loop0;
  1238.                            }
  1239.                            if(eval("\x01") == 143)
  1240.                            {
  1241.                               set("\x01",eval("\x01") + 476);
  1242.                               break loop0;
  1243.                            }
  1244.                            if(eval("\x01") == 995)
  1245.                            {
  1246.                               set("\x01",eval("\x01") - 106);
  1247.                               ┬º┬ºpush(true);
  1248.                            }
  1249.                            else if(eval("\x01") == 251)
  1250.                            {
  1251.                               set("\x01",eval("\x01") + 84);
  1252.                               if(┬º┬ºpop())
  1253.                               {
  1254.                                  set("\x01",eval("\x01") + 660);
  1255.                               }
  1256.                            }
  1257.                            else if(eval("\x01") == 172)
  1258.                            {
  1259.                               set("\x01",eval("\x01") + 490);
  1260.                               ┬º┬ºpush(true);
  1261.                            }
  1262.                            else
  1263.                            {
  1264.                               if(eval("\x01") == 335)
  1265.                               {
  1266.                                  set("\x01",eval("\x01") + 660);
  1267.                                  loop17:
  1268.                                  while(true)
  1269.                                  {
  1270.                                     while(true)
  1271.                                     {
  1272.                                        if(eval("\x01") == 805)
  1273.                                        {
  1274.                                           set("\x01",eval("\x01") - 532);
  1275.                                           ┬º┬ºpush(true);
  1276.                                        }
  1277.                                        else
  1278.                                        {
  1279.                                           if(eval("\x01") == 883)
  1280.                                           {
  1281.                                              set("\x01",eval("\x01") + 54);
  1282.                                              prevFrame();
  1283.                                              break loop0;
  1284.                                           }
  1285.                                           if(eval("\x01") == 273)
  1286.                                           {
  1287.                                              set("\x01",eval("\x01") + 163);
  1288.                                              if(┬º┬ºpop())
  1289.                                              {
  1290.                                                 set("\x01",eval("\x01") - 336);
  1291.                                              }
  1292.                                           }
  1293.                                           else
  1294.                                           {
  1295.                                              if(eval("\x01") == 937)
  1296.                                              {
  1297.                                                 break;
  1298.                                              }
  1299.                                              if(eval("\x01") == 100)
  1300.                                              {
  1301.                                                 set("\x01",eval("\x01") + 566);
  1302.                                                 ┬º┬ºpush(true);
  1303.                                              }
  1304.                                              else if(eval("\x01") == 666)
  1305.                                              {
  1306.                                                 set("\x01",eval("\x01") + 217);
  1307.                                                 if(┬º┬ºpop())
  1308.                                                 {
  1309.                                                    set("\x01",eval("\x01") + 54);
  1310.                                                 }
  1311.                                              }
  1312.                                              else if(eval("\x01") == 502)
  1313.                                              {
  1314.                                                 set("\x01",eval("\x01") - 123);
  1315.                                                 if(┬º┬ºpop())
  1316.                                                 {
  1317.                                                    set("\x01",eval("\x01") - 324);
  1318.                                                 }
  1319.                                              }
  1320.                                              else if(eval("\x01") == 55)
  1321.                                              {
  1322.                                                 set("\x01",eval("\x01") + 227);
  1323.                                                 ┬º┬ºpush(true);
  1324.                                              }
  1325.                                              else
  1326.                                              {
  1327.                                                 if(eval("\x01") == 874)
  1328.                                                 {
  1329.                                                    set("\x01",eval("\x01") - 292);
  1330.                                                    break loop0;
  1331.                                                 }
  1332.                                                 if(eval("\x01") == 436)
  1333.                                                 {
  1334.                                                    break loop17;
  1335.                                                 }
  1336.                                                 if(eval("\x01") == 379)
  1337.                                                 {
  1338.                                                    set("\x01",eval("\x01") - 324);
  1339.                                                    set(┬º┬ºpop(),┬º┬ºpop() - ┬º┬ºpop());
  1340.                                                    break loop0;
  1341.                                                 }
  1342.                                                 if(eval("\x01") == 550)
  1343.                                                 {
  1344.                                                    set("\x01",eval("\x01") + 2);
  1345.                                                    break loop0;
  1346.                                                 }
  1347.                                                 if(eval("\x01") == 282)
  1348.                                                 {
  1349.                                                    set("\x01",eval("\x01") + 592);
  1350.                                                    if(┬º┬ºpop())
  1351.                                                    {
  1352.                                                       set("\x01",eval("\x01") - 292);
  1353.                                                    }
  1354.                                                 }
  1355.                                                 else if(eval("\x01") == 582)
  1356.                                                 {
  1357.                                                    set("\x01",eval("\x01") - 264);
  1358.                                                    ┬º┬ºpush(true);
  1359.                                                 }
  1360.                                                 else
  1361.                                                 {
  1362.                                                    if(eval("\x01") != 318)
  1363.                                                    {
  1364.                                                       if(eval("\x01") == 552)
  1365.                                                       {
  1366.                                                          set("\x01",eval("\x01") - 146);
  1367.                                                          stop();
  1368.                                                       }
  1369.                                                       break loop0;
  1370.                                                    }
  1371.                                                    set("\x01",eval("\x01") + 232);
  1372.                                                    if(┬º┬ºpop())
  1373.                                                    {
  1374.                                                       set("\x01",eval("\x01") + 2);
  1375.                                                    }
  1376.                                                 }
  1377.                                              }
  1378.                                           }
  1379.                                        }
  1380.                                     }
  1381.                                     set("\x01",eval("\x01") - 435);
  1382.                                  }
  1383.                                  set("\x01",eval("\x01") - 336);
  1384.                                  break loop0;
  1385.                               }
  1386.                               if(eval("\x01") == 413)
  1387.                               {
  1388.                                  set("\x01",eval("\x01") - 241);
  1389.                                  ┬º┬ºpush(┬º┬ºpop()());
  1390.                                  break loop0;
  1391.                               }
  1392.                               if(eval("\x01") == 639)
  1393.                               {
  1394.                                  set("\x01",eval("\x01") - 226);
  1395.                                  if(┬º┬ºpop())
  1396.                                  {
  1397.                                     set("\x01",eval("\x01") - 241);
  1398.                                  }
  1399.                               }
  1400.                               else if(eval("\x01") == 619)
  1401.                               {
  1402.                                  set("\x01",eval("\x01") - 368);
  1403.                                  ┬º┬ºpush(true);
  1404.                               }
  1405.                               else if(eval("\x01") == 662)
  1406.                               {
  1407.                                  set("\x01",eval("\x01") - 519);
  1408.                                  if(┬º┬ºpop())
  1409.                                  {
  1410.                                     set("\x01",eval("\x01") + 476);
  1411.                                  }
  1412.                               }
  1413.                               else
  1414.                               {
  1415.                                  if(eval("\x01") != 889)
  1416.                                  {
  1417.                                     if(eval("\x01") == 618)
  1418.                                     {
  1419.                                        set("\x01",eval("\x01") - 602);
  1420.                                     }
  1421.                                     break loop0;
  1422.                                  }
  1423.                                  set("\x01",eval("\x01") - 438);
  1424.                                  if(┬º┬ºpop())
  1425.                                  {
  1426.                                     set("\x01",eval("\x01") + 167);
  1427.                                  }
  1428.                               }
  1429.                            }
  1430.                            while(eval("\x01") == 672)
  1431.                            {
  1432.                               set("\x01",eval("\x01") - 33);
  1433.                               ┬º┬ºpush(true);
  1434.                            }
  1435.                         }
  1436.                      }
  1437.                      else if(eval("\x01") == 485)
  1438.                      {
  1439.                         set("\x01",eval("\x01") - 410);
  1440.                         if(┬º┬ºpop())
  1441.                         {
  1442.                            set("\x01",eval("\x01") + 655);
  1443.                         }
  1444.                      }
  1445.                      else
  1446.                      {
  1447.                         if(eval("\x01") == 689)
  1448.                         {
  1449.                            set("\x01",eval("\x01") + 136);
  1450.                            break loop0;
  1451.                         }
  1452.                         if(eval("\x01") == 356)
  1453.                         {
  1454.                            set("\x01",eval("\x01") + 544);
  1455.                            ┬º┬ºpush(true);
  1456.                         }
  1457.                         else if(eval("\x01") == 129)
  1458.                         {
  1459.                            set("\x01",eval("\x01") + 195);
  1460.                            ┬º┬ºpush(true);
  1461.                         }
  1462.                         else
  1463.                         {
  1464.                            if(eval("\x01") == 336)
  1465.                            {
  1466.                               set("\x01",eval("\x01") + 18);
  1467.                               break loop0;
  1468.                            }
  1469.                            if(eval("\x01") == 354)
  1470.                            {
  1471.                               set("\x01",eval("\x01") + 523);
  1472.                               ┬º┬ºpush(true);
  1473.                            }
  1474.                            else
  1475.                            {
  1476.                               if(eval("\x01") != 877)
  1477.                               {
  1478.                                  if(eval("\x01") == 652)
  1479.                                  {
  1480.                                     set("\x01",eval("\x01") + 157);
  1481.                                     multipleSelection = false;
  1482.                                     ┬º┬ºpush("rowHeight");
  1483.                                     ┬º┬ºpush(20);
  1484.                                  }
  1485.                                  break loop0;
  1486.                               }
  1487.                               set("\x01",eval("\x01") - 77);
  1488.                               if(┬º┬ºpop())
  1489.                               {
  1490.                                  set("\x01",eval("\x01") + 24);
  1491.                               }
  1492.                            }
  1493.                         }
  1494.                      }
  1495.                   }
  1496.                }
  1497.             }
  1498.          }
  1499.       }
  1500.       while(eval("\x01") == 412)
  1501.       {
  1502.          set("\x01",eval("\x01") + 73);
  1503.          ┬º┬ºpush(true);
  1504.       }
  1505.    }
  1506. }
  1507.